package path.calculator;

import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

public class PathCalculator<T extends Comparable<T>> {
    Set<T> nodes = new HashSet<T>();
    HashMap<T, LinkedList<T>> pathFromTo = new HashMap<T, LinkedList<T>>();

    public int totalPaths() {
        PermutationGenerator<T> generator = new PermutationGenerator<T>();
        generator.addAll(nodes);
        List<Permutation<T>> allPermutations = generator.allCombinations();
        List<Permutation<T>> validPermutations = new LinkedList<Permutation<T>>();
        for (Permutation<T> current : allPermutations)
            if (isValidPermutation(current))
                validPermutations.add(current);

        return validPermutations.size();
    }

    private boolean isValidPermutation(Permutation<T> current) {
        for (int i = current.length() - 1; i > 0; --i)
            for (int j = i - 1; j >= 0; --j)
                if (pathExistsFrom(current.get(j), current.get(i)))
                    return false;

        return true;
    }

    private boolean pathEsistsFrom(T from, T to) {
    }

    public void mustFlowFromNodeToNode(T previous, T latter) {
        if (!pathFromTo.containsKey(previous))
            pathFromTo.put(previous, new LinkedList<T>());

        pathFromTo.get(previous).add(latter);
    }

    public void addNodes(T... values) {
        for (T t : values)
            this.nodes.add(t);
    }
}
